home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK2.toast / Development Kits (Disc 2) / QuickDraw GX / Programming Stuff / GXEdit Library & Doc / GXEdit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-10  |  16.4 KB  |  1,098 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:                GXEdit.c
  3.     
  4.     Contains:
  5.     
  6.     Written by:        Barton R. House
  7.     
  8.     Copyright:        © 1993 by Apple Computer, Inc., All rights reserved.
  9.     
  10. */
  11.  
  12. #include "GXEdit.h"
  13. #include "GXEditDoc.h"
  14. #include "GXEditValidation.h"
  15. #include "GXEditDebug.h"
  16. #include "GXEditError.h"
  17. #include "GXEditUtils.h"
  18.  
  19. #include "math routines.h"
  20.  
  21. #ifndef layoutTypesIncludes
  22. #include "layout types.h"
  23. #endif
  24.  
  25. void GXEditNew(GXEditDoc * docHanPtr, gxRectangle * viewRect, gxViewPort docViewPort, fixed leftMargin, fixed rightMargin)
  26. {
  27.     Rect        rect;
  28.     short    left;
  29.     short    right;
  30.     
  31.     rect.top = FixedToInt(viewRect->top);
  32.     rect.bottom = FixedToInt(viewRect->bottom);
  33.     rect.left = FixedToInt(viewRect->left);
  34.     rect.right = FixedToInt(viewRect->right);
  35.     
  36.     left = FixedToInt(leftMargin);
  37.     right = FixedToInt(rightMargin);
  38.     
  39.     NewDoc((DocHan *) docHanPtr, &rect, (void *) docViewPort, left, right);
  40.     
  41. }
  42.  
  43. void GXEditDispose(GXEditDoc doc)
  44. {
  45.     DisposeDoc((DocHan) doc);
  46. }
  47.  
  48. void GXEditSetSelection(GXEditDoc doc, long selStart, long selEnd)
  49. {
  50.     DocPtr            dp;
  51.     
  52.     HLock((Handle) doc);
  53.     
  54.     dp = *((DocHan) doc);
  55.     dp->error = gx_edit_no_error;
  56.     
  57.     if(ValidateDoc(dp))    {
  58.     
  59.         DocSetSelection(dp, selStart, selEnd);
  60.         
  61.         ValidateDoc(dp);
  62.         
  63.     }
  64.     
  65.     HUnlock((Handle) doc);
  66. }
  67.  
  68. void GXEditInsert(GXEditDoc doc, void * text, short startNumText)
  69. {
  70.     DocPtr        dp;
  71.  
  72.     HLock((Handle) doc);
  73.     
  74.     dp = *((DocHan) doc);
  75.     dp->error = gx_edit_no_error;
  76.     
  77.     if(ValidateDoc(dp)) {
  78.     
  79.         DocInsert(dp, text, startNumText);
  80.  
  81.         ValidateDoc(dp);
  82.         
  83.     }
  84.  
  85.     HUnlock((Handle) doc);
  86.         
  87. }
  88.  
  89. void GXEditClear(GXEditDoc doc)
  90. {
  91.     DocPtr            dp;
  92.     
  93.     HLock((Handle) doc);
  94.     
  95.     dp = *((DocHan) doc);
  96.     dp->error = gx_edit_no_error;
  97.     
  98.     if(ValidateDoc(dp)) {
  99.     
  100.         DocClear(dp);
  101.     
  102.         ValidateDoc(dp);
  103.         
  104.     }
  105.  
  106.     HUnlock((Handle) doc);
  107.  
  108. }
  109.  
  110. void GXEditUpdate(GXEditDoc doc, gxRectangle * updateRect)
  111. {
  112.     DocPtr            dp;
  113.     
  114.     HLock((Handle) doc);
  115.     
  116.     dp = *((DocHan) doc);
  117.     dp->error = gx_edit_no_error;
  118.     
  119.     if(ValidateDoc(dp)) {
  120.     
  121.         DocUpdate(dp, updateRect);
  122.         
  123.         ValidateDoc(dp);
  124.         
  125.     }
  126.  
  127.     HUnlock((Handle) doc);
  128.  
  129. }
  130.  
  131. void GXEditClick(GXEditDoc doc, gxPoint where, Boolean extend)
  132. {
  133.     DocPtr            dp;
  134.     Point                pt;
  135.     
  136.     HLock((Handle) doc);
  137.     
  138.     dp = *((DocHan) doc);
  139.     dp->error = gx_edit_no_error;
  140.     
  141.     pt.h = FixedToInt(where.x);
  142.     pt.v = FixedToInt(where.y);
  143.     
  144.     if(ValidateDoc(dp)) {
  145.     
  146.         DocClick(dp, pt, extend);
  147.     
  148.         ValidateDoc(dp);
  149.  
  150.     }
  151.     
  152.     HUnlock((Handle) doc);
  153.  
  154. }
  155.  
  156. void GXEditScroll(GXEditDoc doc, short dv)
  157. {
  158.     DocPtr            dp;
  159.     
  160.     HLock((Handle) doc);
  161.     
  162.     dp = *((DocHan) doc);
  163.     dp->error = gx_edit_no_error;
  164.     
  165.     if(ValidateDoc(dp)) {
  166.     
  167.         DocScroll(dp, dv);
  168.     
  169.         ValidateDoc(dp);
  170.         
  171.     }
  172.  
  173.     HUnlock((Handle) doc);
  174.  
  175. }
  176.  
  177. long GXEditHeight(GXEditDoc doc)
  178. {
  179.     DocPtr            dp;
  180.     long            height;
  181.     
  182.     HLock((Handle) doc);
  183.     
  184.     dp = *((DocHan) doc);
  185.     dp->error = gx_edit_no_error;
  186.     
  187.     if(ValidateDoc(dp)) {
  188.     
  189.         height = DocHeight(dp);
  190.         
  191.         ValidateDoc(dp);
  192.  
  193.     } else
  194.         height = 0;
  195.     
  196.     HUnlock((Handle) doc);
  197.     
  198.     return(height);
  199.  
  200. }
  201.  
  202. void GXEditSize(GXEditDoc doc, gxRectangle * viewRect)
  203. {
  204.     DocPtr            dp;
  205.     Rect                rect;
  206.     
  207.     HLock((Handle) doc);
  208.     
  209.     dp = *((DocHan) doc);
  210.     dp->error = gx_edit_no_error;
  211.     
  212.     rect.top = FixedToInt(viewRect->top);
  213.     rect.bottom = FixedToInt(viewRect->bottom);
  214.     rect.left = FixedToInt(viewRect->left);
  215.     rect.right = FixedToInt(viewRect->right);
  216.     
  217.     if(ValidateDoc(dp)) {
  218.     
  219.         DocSize(dp, &rect);
  220.     
  221.         ValidateDoc(dp);
  222.         
  223.     }
  224.  
  225.     HUnlock((Handle) doc);
  226.  
  227. }
  228.  
  229. long GXEditGetTop(GXEditDoc doc)
  230. {
  231.     DocPtr            dp;
  232.     long            top;
  233.     
  234.     HLock((Handle) doc);
  235.     
  236.     dp = *((DocHan) doc);
  237.     dp->error = gx_edit_no_error;
  238.     
  239.     if(ValidateDoc(dp)) {
  240.     
  241.         top = DocGetTop(dp);
  242.         
  243.         ValidateDoc(dp);
  244.  
  245.     } else
  246.         top = 0;
  247.         
  248.     HUnlock((Handle) doc);
  249.     
  250.     return(top);
  251.  
  252. }
  253.  
  254. long GXEditGetMaxTop(GXEditDoc doc)
  255. {
  256.     DocPtr            dp;
  257.     long            maxTop;
  258.     
  259.     HLock((Handle) doc);
  260.     
  261.     dp = *((DocHan) doc);
  262.     dp->error = gx_edit_no_error;
  263.     
  264.     if(ValidateDoc(dp)) {
  265.     
  266.         maxTop = DocGetMaxTop(dp);
  267.         
  268.         ValidateDoc(dp);
  269.  
  270.     } else
  271.         maxTop = 0;
  272.     
  273.     HUnlock((Handle) doc);
  274.  
  275.     return(maxTop);
  276. }
  277.  
  278. void GXEditKey(GXEditDoc doc, char key)
  279. {
  280.     DocPtr            dp;
  281.     
  282.     HLock((Handle) doc);
  283.     
  284.     dp = *((DocHan) doc);
  285.     dp->error = gx_edit_no_error;
  286.     
  287.     if(ValidateDoc(dp)) {
  288.     
  289.         DocKey(dp, key);
  290.     
  291.         ValidateDoc(dp);
  292.         
  293.     }
  294.  
  295.     HUnlock((Handle) doc);
  296.  
  297. }
  298.  
  299. void GXEditSetTextFonts(GXEditDoc doc, short numFonts, gxFont * srcFonts, gxFont * dstFonts)
  300. {
  301.     DocPtr            dp;
  302.     
  303.     HLock((Handle) doc);
  304.     
  305.     dp = *((DocHan) doc);
  306.     dp->error = gx_edit_no_error;
  307.     
  308.     if(ValidateDoc(dp)) {
  309.     
  310.         if(GXEditDebug) {
  311.             AddBlock((long) srcFonts, numFonts * sizeof(gxFont), false);
  312.             AddBlock((long) dstFonts, numFonts * sizeof(gxFont), false);
  313.         }
  314.         
  315.         DocSetTextFonts(dp, numFonts, srcFonts, dstFonts);
  316.  
  317.         if(GXEditDebug) {
  318.             RemoveBlock((long) srcFonts);
  319.             RemoveBlock((long) dstFonts);
  320.         }
  321.         
  322.     
  323.         ValidateDoc(dp);
  324.     
  325.     }
  326.     
  327.     HUnlock((Handle) doc);
  328.         
  329.  
  330. }
  331.  
  332. void GXEditGetTextFonts(GXEditDoc doc, short * numFonts, gxFont * fonts)
  333. {
  334.     DocPtr            dp;
  335.     gxFont            textFont;
  336.     
  337.     HLock((Handle) doc);
  338.     
  339.     dp = *((DocHan) doc);
  340.     dp->error = gx_edit_no_error;
  341.     
  342.     if(ValidateDoc(dp)) {
  343.     
  344.         if(GXEditDebug && fonts != nil)
  345.             AddBlock((long) fonts, 0x7fffffff, false);
  346.     
  347.         DocGetTextFonts(dp, numFonts, fonts);
  348.         
  349.         if(GXEditDebug && fonts != nil)
  350.             RemoveBlock((long) fonts);
  351.  
  352.         ValidateDoc(dp);
  353.  
  354.     } else
  355.         textFont = nil;        /* this is the default gxFont */        
  356.     
  357.     HUnlock((Handle) doc);
  358.     
  359. }
  360.  
  361. void GXEditSetTextSize(GXEditDoc doc, short size)
  362. {
  363.     DocPtr            dp;
  364.     
  365.     HLock((Handle) doc);
  366.     
  367.     dp = *((DocHan) doc);
  368.     dp->error = gx_edit_no_error;
  369.     
  370.     if(ValidateDoc(dp)) {
  371.     
  372.         DocSetTextSize(dp, size);
  373.     
  374.         ValidateDoc(dp);
  375.         
  376.     }
  377.  
  378.     HUnlock((Handle) doc);
  379.  
  380. }
  381.  
  382. short GXEditGetTextSize(GXEditDoc doc)
  383. {
  384.     DocPtr            dp;
  385.     short            size;
  386.     
  387.     HLock((Handle) doc);
  388.     
  389.     dp = *((DocHan) doc);
  390.     dp->error = gx_edit_no_error;
  391.     
  392.     if(ValidateDoc(dp)) {
  393.     
  394.         size = DocGetTextSize(dp);
  395.  
  396.         ValidateDoc(dp);
  397.  
  398.     } else
  399.         size = 0;
  400.     
  401.     HUnlock((Handle) doc);
  402.  
  403.     return(size);
  404. }
  405.  
  406. void GXEditSetFeatures(GXEditDoc doc, gxFont fontId, short numFeatureGroups,
  407.                                     short * srcFeatureGroupSizes,
  408.                                     gxRunFeature ** srcFeatureGroups,
  409.                                     short * dstFeatureGroupSizes,
  410.                                     gxRunFeature ** dstFeatureGroups)
  411. {
  412.     DocPtr            dp;
  413.     short            i;
  414.     
  415.     HLock((Handle) doc);
  416.     
  417.     dp = *((DocHan) doc);
  418.     dp->error = gx_edit_no_error;
  419.     
  420.     if(ValidateDoc(dp)) {
  421.     
  422.         if(GXEditDebug)
  423.             for(i=0; i<numFeatureGroups; i++) {
  424.                 AddBlock((long) srcFeatureGroups[i],
  425.                                 sizeof(gxRunFeature) * srcFeatureGroupSizes[i], false);
  426.                 AddBlock((long) dstFeatureGroups[i],
  427.                                 sizeof(gxRunFeature) * dstFeatureGroupSizes[i], false);
  428.             }
  429.         
  430.         DocSetFeatures(dp, fontId, numFeatureGroups,
  431.                                 srcFeatureGroupSizes, srcFeatureGroups,
  432.                                 dstFeatureGroupSizes, dstFeatureGroups);
  433.         
  434.         if(GXEditDebug)
  435.             for(i=0; i<numFeatureGroups; i++) {
  436.                 RemoveBlock((long) srcFeatureGroups[i]);
  437.                 RemoveBlock((long) dstFeatureGroups[i]);
  438.             }
  439.         
  440.         ValidateDoc(dp);
  441.         
  442.     }
  443.     
  444.     HUnlock((Handle) doc);
  445.     
  446. }
  447.  
  448. void GXEditGetFeatures(GXEditDoc doc, gxFont fontId, short * numFeatureGroupsPtr,
  449.                                 short *** featureGroupSizesPtr,
  450.                                 gxRunFeature **** featureGroupsPtr)
  451.  
  452. {
  453.     DocPtr            dp;
  454.     short            i;
  455.     
  456.     HLock((Handle) doc);
  457.     
  458.     dp = *((DocHan) doc);
  459.     dp->error = gx_edit_no_error;
  460.     
  461.     if(ValidateDoc(dp)) {
  462.             
  463.         DocGetFeatures(dp, fontId, numFeatureGroupsPtr,
  464.                                         featureGroupSizesPtr, featureGroupsPtr);
  465.         
  466.         if(GXEditDebug) {
  467.             RemoveBlock((long) *featureGroupSizesPtr);
  468.             for(i=0; i<*numFeatureGroupsPtr; i++)
  469.                 RemoveBlock((long) (**featureGroupsPtr)[i]);
  470.             RemoveBlock((long) *featureGroupsPtr);
  471.         }
  472.         
  473.         ValidateDoc(dp);
  474.         
  475.     }
  476.     
  477.     HUnlock((Handle) doc);
  478.     
  479. }
  480.  
  481. void GXEditSetVariations(GXEditDoc doc, gxFont fontId, short numVariations,
  482.                                                             gxFontVariation * variations)
  483. {
  484.     DocPtr            dp;
  485.     
  486.     HLock((Handle) doc);
  487.     
  488.     dp = *((DocHan) doc);
  489.     dp->error = gx_edit_no_error;
  490.     
  491.     if(ValidateDoc(dp)) {
  492.     
  493.         if(GXEditDebug)
  494.             AddBlock((long) variations, numVariations * sizeof(gxFontVariation), false);
  495.             
  496.         DocSetVariations(dp, fontId, numVariations, variations);
  497.         
  498.         if(GXEditDebug)
  499.             RemoveBlock((long) variations);
  500.             
  501.         ValidateDoc(dp);
  502.  
  503.     }
  504.     
  505.     HUnlock((Handle) doc);
  506.  
  507. }
  508.  
  509. void GXEditGetVariations(GXEditDoc doc, gxFont fontId, short * numInstancesPtr,
  510.                         short *** instanceSizesPtr, gxFontVariation **** instancesPtr)
  511. {
  512.     DocPtr            dp;
  513.     short            i;
  514.     
  515.     HLock((Handle) doc);
  516.     
  517.     dp = *((DocHan) doc);
  518.     dp->error = gx_edit_no_error;
  519.     
  520.     if(ValidateDoc(dp)) {
  521.     
  522.         DocGetVariations(dp, fontId, numInstancesPtr, instanceSizesPtr, instancesPtr);
  523.         
  524.         if(GXEditDebug) {
  525.             RemoveBlock((long) *instanceSizesPtr);
  526.             for(i=0; i<*numInstancesPtr; i++)
  527.                 RemoveBlock((long) (**instancesPtr)[i]);
  528.             RemoveBlock((long) *instancesPtr);
  529.         }
  530.         
  531.         ValidateDoc(dp);
  532.         
  533.     }
  534.  
  535.     HUnlock((Handle) doc);
  536.  
  537. }
  538.  
  539. void GXEditGetSelectionStyles(GXEditDoc doc, short * numStyles, gxStyle  * styles)
  540. {
  541.     DocPtr            dp;
  542.     
  543.     HLock((Handle) doc);
  544.     
  545.     dp = *((DocHan) doc);
  546.     dp->error = gx_edit_no_error;
  547.     
  548.     if(ValidateDoc(dp)) {
  549.     
  550.         DocGetSelectionStyles(dp, numStyles, styles);
  551.                 
  552.         ValidateDoc(dp);
  553.         
  554.     }
  555.  
  556.     HUnlock((Handle) doc);
  557.  
  558. }
  559.  
  560. void GXEditSetSelectionStyles(GXEditDoc doc,  gxStyle  * toStyles)
  561. {
  562.     DocPtr            dp;
  563.     
  564.     HLock((Handle) doc);
  565.     
  566.     dp = *((DocHan) doc);
  567.     dp->error = gx_edit_no_error;
  568.     
  569.     if(ValidateDoc(dp)) {
  570.     
  571.         DocSetSelectionStyles(dp, toStyles);
  572.                 
  573.         ValidateDoc(dp);
  574.         
  575.     }
  576.  
  577.     HUnlock((Handle) doc);
  578.  
  579. }
  580.  
  581. void GXEditGetRunControls(GXEditDoc doc, gxRunControls * runControls, gxRunControls * mask)
  582. {
  583.     DocPtr            dp;
  584.     
  585.     HLock((Handle) doc);
  586.     
  587.     dp = *((DocHan) doc);
  588.     dp->error = gx_edit_no_error;
  589.     
  590.     if(ValidateDoc(dp)) {
  591.     
  592.         DocGetRunControls(dp, runControls, mask);
  593.     
  594.         ValidateDoc(dp);
  595.         
  596.     }
  597.  
  598.     HUnlock((Handle) doc);
  599.  
  600. }
  601.  
  602. void GXEditSetRunControls(GXEditDoc doc, gxRunControls * runControls, gxRunControls * mask)
  603. {
  604.     DocPtr            dp;
  605.     
  606.     HLock((Handle) doc);
  607.     
  608.     dp = *((DocHan) doc);
  609.     dp->error = gx_edit_no_error;
  610.     
  611.     if(ValidateDoc(dp)) {
  612.     
  613.         DocSetRunControls(dp, runControls, mask);
  614.     
  615.         ValidateDoc(dp);
  616.  
  617.     }
  618.     
  619.     HUnlock((Handle) doc);
  620.  
  621. }
  622.  
  623. void GXEditGetFontRunControls(GXEditDoc doc, gxFont fontID, gxRunControls * runControls, gxRunControls * mask)
  624. {
  625.     DocPtr            dp;
  626.     
  627.     HLock((Handle) doc);
  628.     
  629.     dp = *((DocHan) doc);
  630.     dp->error = gx_edit_no_error;
  631.     
  632.     if(ValidateDoc(dp)) {
  633.     
  634.         DocGetFontRunControls(dp, fontID, runControls, mask);
  635.     
  636.         ValidateDoc(dp);
  637.         
  638.     }
  639.  
  640.     HUnlock((Handle) doc);
  641.  
  642. }
  643.  
  644. void GXEditGetLayoutOptions(GXEditDoc doc, gxLayoutOptions * options, gxLayoutOptions * mask)
  645. {
  646.     DocPtr            dp;
  647.     
  648.     HLock((Handle) doc);
  649.     
  650.     dp = *((DocHan) doc);
  651.     dp->error = gx_edit_no_error;
  652.     
  653.     if(ValidateDoc(dp)) {
  654.     
  655.         DocGetLayoutOptions(dp, options, mask);
  656.     
  657.         ValidateDoc(dp);
  658.         
  659.     }
  660.  
  661.     HUnlock((Handle) doc);
  662.  
  663. }
  664.  
  665. void GXEditSetLayoutOptions(GXEditDoc doc, gxLayoutOptions * options, gxLayoutOptions * mask)
  666. {
  667.     DocPtr            dp;
  668.     
  669.     HLock((Handle) doc);
  670.     
  671.     dp = *((DocHan) doc);
  672.     dp->error = gx_edit_no_error;
  673.     
  674.     if(ValidateDoc(dp)) {
  675.     
  676.         DocSetLayoutOptions(dp, options, mask);
  677.     
  678.         ValidateDoc(dp);
  679.  
  680.     }
  681.     
  682.     HUnlock((Handle) doc);
  683.  
  684. }
  685.  
  686. void GXEditPrint(GXEditDoc doc, gxJob printJob)
  687. {
  688.     DocPtr            dp;
  689.     
  690.     HLock((Handle) doc);
  691.     
  692.     dp = *((DocHan) doc);
  693.     dp->error = gx_edit_no_error;
  694.     
  695.     if(ValidateDoc(dp)) {
  696.     
  697.         DocPrint(dp, printJob);
  698.     
  699.         ValidateDoc(dp);
  700.  
  701.     }
  702.     
  703.     HUnlock((Handle) doc);
  704.  
  705. }
  706.  
  707. void GXEditCopy(GXEditDoc doc)
  708. {
  709.     DocPtr            dp;
  710.     
  711.     HLock((Handle) doc);
  712.     
  713.     dp = *((DocHan) doc);
  714.     dp->error = gx_edit_no_error;
  715.     
  716.     if(ValidateDoc(dp)) {
  717.     
  718.         DocCopy(dp);
  719.     
  720.         ValidateDoc(dp);
  721.         
  722.     }
  723.  
  724.     HUnlock((Handle) doc);
  725.  
  726. }
  727.  
  728. void GXEditCut(GXEditDoc doc)
  729. {
  730.  
  731.     DocPtr            dp;
  732.     
  733.     HLock((Handle) doc);
  734.     
  735.     dp = *((DocHan) doc);
  736.     dp->error = gx_edit_no_error;
  737.     
  738.     if(ValidateDoc(dp)) {
  739.     
  740.         DocCopy(dp);
  741.     
  742.         DocClear(dp);
  743.     
  744.         ValidateDoc(dp);
  745.         
  746.     }
  747.  
  748.     HUnlock((Handle) doc);
  749.  
  750. }
  751.  
  752. void GXEditPaste(GXEditDoc doc)
  753. {
  754.     DocPtr            dp;
  755.     
  756.     HLock((Handle) doc);
  757.     
  758.     dp = *((DocHan) doc);
  759.     dp->error = gx_edit_no_error;
  760.     
  761.     if(ValidateDoc(dp)) {
  762.     
  763.         DocPaste(dp);
  764.     
  765.         ValidateDoc(dp);
  766.         
  767.     }
  768.  
  769.     HUnlock((Handle) doc);
  770.  
  771. }
  772.  
  773. long GXEditGetScrapLength(GXEditDoc doc)
  774. {
  775.     DocPtr            dp;
  776.     long            len;
  777.     
  778.     HLock((Handle) doc);
  779.     
  780.     dp = *((DocHan) doc);
  781.     dp->error = gx_edit_no_error;
  782.     
  783.     if(ValidateDoc(dp)) {
  784.     
  785.         len = DocGetScrapLen(dp);
  786.         
  787.         ValidateDoc(dp);
  788.  
  789.     } else
  790.         len = 0;
  791.         
  792.     HUnlock((Handle) doc);
  793.  
  794.     return(len);
  795. }
  796.  
  797. long GXEditGetSelectionLength(GXEditDoc doc)
  798. {
  799.     DocPtr            dp;
  800.     long            len;
  801.     
  802.     HLock((Handle) doc);
  803.     
  804.     dp = *((DocHan) doc);
  805.     dp->error = gx_edit_no_error;
  806.     
  807.     if(ValidateDoc(dp)) {
  808.     
  809.         len = DocGetSelectionLen(dp);
  810.         
  811.         ValidateDoc(dp);
  812.  
  813.     } else
  814.         len = 0;
  815.     
  816.     HUnlock((Handle) doc);
  817.  
  818.     return(len);
  819. }
  820.  
  821. long GXEditGetTextLength(GXEditDoc doc)
  822. {
  823.     DocPtr            dp;
  824.     long            len;
  825.     
  826.     HLock((Handle) doc);
  827.     
  828.     dp = *((DocHan) doc);
  829.     dp->error = gx_edit_no_error;
  830.     
  831.     if(ValidateDoc(dp)) {
  832.     
  833.         len = DocGetTextLen(dp);
  834.         
  835.         ValidateDoc(dp);
  836.  
  837.     } else
  838.         len = 0;
  839.     
  840.     HUnlock((Handle) doc);
  841.  
  842.     return(len);
  843. }
  844.  
  845. Boolean GXEditIdle(GXEditDoc doc)
  846. {
  847.     DocPtr            dp;
  848.     Boolean            modified;
  849.     
  850.     HLock((Handle) doc);
  851.     
  852.     dp = *((DocHan) doc);
  853.     dp->error = gx_edit_no_error;
  854.     
  855.     if(ValidateDoc(dp)) {
  856.     
  857.         modified = DocIdle(dp);
  858.     
  859.         ValidateDoc(dp);
  860.         
  861.     }
  862.  
  863.     HUnlock((Handle) doc);
  864.     
  865.     return(modified);
  866.  
  867. }
  868.  
  869. void GXEditSave(GXEditDoc doc, short fRefNum)
  870. {
  871.     DocPtr            dp;
  872.     
  873.     HLock((Handle) doc);
  874.     
  875.     dp = *((DocHan) doc);
  876.     dp->error = gx_edit_no_error;
  877.     
  878.     if(ValidateDoc(dp)) {
  879.     
  880.         DocSave(dp, fRefNum);
  881.     
  882.         ValidateDoc(dp);
  883.         
  884.     }
  885.  
  886.     HUnlock((Handle) doc);
  887.  
  888. }
  889.  
  890. void GXEditOpen(GXEditDoc * doc, Rect * viewRect, gxViewPort docViewPort, short fRefNum, 
  891.                                                         fixed leftMargin, fixed rightMargin)
  892. {
  893.     short        left;
  894.     short        right;
  895.     
  896.     left = FixedToInt(leftMargin);
  897.     right = FixedToInt(rightMargin);
  898.     
  899.     DocOpen((DocHan *) doc, viewRect, docViewPort, fRefNum, left, right);
  900.     
  901.     HLock((Handle) *doc);
  902.     
  903.     ValidateDoc(**((DocHan *) doc));
  904.  
  905.     HUnlock((Handle) *doc);
  906. }
  907.  
  908.  
  909. void GXEditGetError(GXEditDoc doc, GXEditError * error, GXEditError * stickyError)
  910. {
  911.     DocPtr            dp;
  912.     
  913.     HLock((Handle) doc);
  914.  
  915.     dp = *((DocHan) doc);
  916.     dp->error = gx_edit_no_error;
  917.     
  918.     if(ValidateDoc(dp) || dp->magic == kGXEditMagic)
  919.         gxEditGetError(dp, error, stickyError);
  920.     else {
  921.         if(error != nil)
  922.             *error = gx_edit_bad_magic;
  923.         if(stickyError != nil)
  924.             *error = gx_edit_bad_magic;
  925.         }
  926.  
  927.     HUnlock((Handle) doc);
  928.  
  929. }
  930.  
  931. void GXEditGetUserError(GXEditDoc doc, GXEditUserErrorProc * userProc, void ** reference)
  932. {
  933.     DocPtr            dp;
  934.     
  935.     HLock((Handle) doc);
  936.  
  937.     dp = *((DocHan) doc);
  938.     dp->error = gx_edit_no_error;
  939.     
  940.     if(ValidateDoc(dp))
  941.         gxEditGetUserError(dp, userProc, reference);
  942.  
  943.     HUnlock((Handle) doc);
  944.  
  945. }
  946.  
  947. void GXEditSetUserError(GXEditDoc doc, GXEditUserErrorProc userProc, void * reference)
  948. {
  949.     DocPtr            dp;
  950.     
  951.     HLock((Handle) doc);
  952.  
  953.     dp = *((DocHan) doc);
  954.     dp->error = gx_edit_no_error;
  955.     
  956.     if(ValidateDoc(dp))
  957.         gxEditSetUserError(dp, userProc, reference);
  958.  
  959.     HUnlock((Handle) doc);
  960.  
  961. }
  962.  
  963. void GXEditFlushCaches(GXEditDoc doc)
  964. {
  965.     DocPtr            dp;
  966.     
  967.     HLock((Handle) doc);
  968.  
  969.     dp = *((DocHan) doc);
  970.     dp->error = gx_edit_no_error;
  971.     
  972.     if (ValidateDoc(dp))
  973.         gxEditFlushCaches(dp);
  974.  
  975.     ValidateDoc(dp);
  976.  
  977.     HUnlock((Handle) doc);
  978. }
  979.  
  980. void GXEditProof(GXEditDoc doc, GXEditProofPtr proof)
  981. {
  982.     DocPtr            dp;
  983.     
  984.     HLock((Handle) doc);
  985.  
  986.     dp = *((DocHan) doc);
  987.     dp->error = gx_edit_no_error;
  988.     
  989.     if (ValidateDoc(dp))
  990.         DocProof(dp, proof);
  991.  
  992.     ValidateDoc(dp);
  993.  
  994.     HUnlock((Handle) doc);
  995. }
  996.  
  997. extern void GXEditActivate(GXEditDoc doc, Boolean activate)
  998. {
  999.     DocPtr            dp;
  1000.     
  1001.     HLock((Handle) doc);
  1002.  
  1003.     dp = *((DocHan) doc);
  1004.     dp->error = gx_edit_no_error;
  1005.     
  1006.     if (ValidateDoc(dp))
  1007.         DocActivate(dp, activate);
  1008.  
  1009.     ValidateDoc(dp);
  1010.  
  1011.     HUnlock((Handle) doc);
  1012. }
  1013.  
  1014. extern void GXEditSetEncoding(GXEditDoc doc, gxFontPlatform platform, gxFontScript script, gxFontLanguage language)
  1015. {
  1016.     DocPtr            dp;
  1017.     
  1018.     HLock((Handle) doc);
  1019.  
  1020.     dp = *((DocHan) doc);
  1021.     dp->error = gx_edit_no_error;
  1022.     
  1023.     if (ValidateDoc(dp))
  1024.         DocSetEncoding(dp, platform, script, language);
  1025.         
  1026.     ValidateDoc(dp);
  1027.  
  1028.     HUnlock((Handle) doc);
  1029. }
  1030.  
  1031. extern void GXEditSetVerticalText(GXEditDoc doc, Boolean enable)
  1032. {
  1033.     DocPtr            dp;
  1034.     
  1035.     HLock((Handle) doc);
  1036.  
  1037.     dp = *((DocHan) doc);
  1038.     dp->error = gx_edit_no_error;
  1039.     
  1040.     if (ValidateDoc(dp))
  1041.         DocSetVerticalText(dp,enable);
  1042.  
  1043.     ValidateDoc(dp);
  1044.  
  1045.     HUnlock((Handle) doc);
  1046. }
  1047.  
  1048. extern void GXEditGetVerticalText(GXEditDoc doc, Boolean * enable)
  1049. {
  1050.     DocPtr            dp;
  1051.     
  1052.     HLock((Handle) doc);
  1053.  
  1054.     dp = *((DocHan) doc);
  1055.     dp->error = gx_edit_no_error;
  1056.     
  1057.     if (ValidateDoc(dp))
  1058.         DocGetVerticalText(dp,enable);
  1059.  
  1060.     ValidateDoc(dp);
  1061.  
  1062.     HUnlock((Handle) doc);
  1063. }
  1064.  
  1065. extern void GXEditGetSelectionEncoding(GXEditDoc doc, gxFontPlatform * platform, gxFontScript * script, gxFontLanguage * language)
  1066. {
  1067.     DocPtr            dp;
  1068.     
  1069.     HLock((Handle) doc);
  1070.  
  1071.     dp = *((DocHan) doc);
  1072.     dp->error = gx_edit_no_error;
  1073.     
  1074.     if (ValidateDoc(dp))
  1075.         DocGetSelectionEncoding(dp, platform, script, language);
  1076.  
  1077.     ValidateDoc(dp);
  1078.  
  1079.     HUnlock((Handle) doc);
  1080. }
  1081.  
  1082. extern void GXEditSetSelectionEncoding(GXEditDoc doc, gxFontPlatform platform, gxFontScript script, gxFontLanguage language)
  1083. {
  1084.     DocPtr            dp;
  1085.     
  1086.     HLock((Handle) doc);
  1087.  
  1088.     dp = *((DocHan) doc);
  1089.     dp->error = gx_edit_no_error;
  1090.     
  1091.     if (ValidateDoc(dp))
  1092.         DocSetSelectionEncoding(dp, platform, script, language);
  1093.  
  1094.     ValidateDoc(dp);
  1095.  
  1096.     HUnlock((Handle) doc);
  1097. }
  1098.